<!DOCTYPE html>
<html>

<head>
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
  <title>testJs</title>
  <!-- <script src="/public/processingString/index.js"></script> -->
</head>

<body>
  aaaaa
  <script>
  /* 原型继承 */
  // var Parent = function(){
  //   this.name = "parent";
  // };
  // Parent.prototype.getName = function(){
  //   return this.name;
  // };
  // var Child = function(){
  //   this.name = "child";
  // };
  // Child.prototype = new Parent();

  /* 类式继承 */
  // var father = function(){
  //   this.age = 19;
  //   this.say = function(){
  //     console.log("hello",this.name);
  //   };
  // };

  // var child = function(){
  //   this.name = "Think";
  //   father.apply(this);
  // };

  // var man = new child();
  // man.say();


  // 简单工厂模式
  // function CreatePerson(name,age,sex) {
  //     var obj = new Object();
  //     obj.name = name;
  //     obj.age = age;
  //     obj.sex = sex;
  //     obj.sayName = function(){
  //         return this.name;
  //     }
  //     return obj;
  // }
  // var p1 =  CreatePerson("longen",'28','男');
  // var p2 =  CreatePerson("tugenhua",'27','女');
  // console.log(p1.name,p2.name)

  //复杂工厂模式
  // var BicycleShop = function(name) {
  //   this.name = name;
  //   this.method = function() {
  //     return this.name;
  //   }
  // };
  // BicycleShop.prototype = {
  //   constructor: BicycleShop,
  //   /*
  //    * 买自行车这个方法
  //    * @param {model} 自行车型号
  //    */
  //   sellBicycle: function(model) {
  //     var bicycle = this.createBicycle(model);
  //     // 执行A业务逻辑
  //     bicycle.A();

  //     // 执行B业务逻辑
  //     bicycle.B();

  //     return bicycle;
  //   },
  //   createBicycle: function(model) {
  //     throw new Error("父类是抽象类不能直接调用，需要子类重写该方法");
  //   }
  // };

  // // 实现原型继承
  // function extend(Sub, Sup) {
  //   //Sub表示子类，Sup表示超类
  //   // 首先定义一个空函数
  //   var F = function() {};

  //   // 设置空函数的原型为超类的原型
  //   F.prototype = Sup.prototype;

  //   // 实例化空函数，并把超类原型引用传递给子类
  //   Sub.prototype = new F();

  //   // 重置子类原型的构造器为子类自身
  //   Sub.prototype.constructor = Sub;

  //   // 在子类中保存超类的原型,避免子类与超类耦合
  //   Sub.sup = Sup.prototype;

  //   if (Sup.prototype.constructor === Object.prototype.constructor) {
  //     // 检测超类原型的构造器是否为原型自身
  //     Sup.prototype.constructor = Sup;
  //   }
  // };

  // var BicycleChild = function(name) {
  //   this.name = name;
  //   // 继承构造函数父类中的属性和方法
  //   BicycleShop.call(this, name);
  // };
  // // 子类继承父类原型方法
  // extend(BicycleChild, BicycleShop);

  // // BicycleChild 子类重写父类的方法
  // BicycleChild.prototype.createBicycle = function() {
  //   var A = function() {
  //     console.log("执行A业务操作");
  //   };
  //   var B = function() {
  //     console.log("执行B业务操作");
  //   };
  //   return {
  //     A: A,
  //     B: B
  //   }
  // };

  // var childClass = new BicycleChild("龙恩");
  // console.log(childClass);

  // 单体模式   可以被实例化，且实例化一次。
  var Singleton = function(name){
      this.name = name;
      this.instance = null;
  };
  Singleton.prototype.getName = function(){
      return this.name;
  }
  // 获取实例对象
  function getInstance(name) {
      if(!this.instance) {
          this.instance = new Singleton(name);
      }
      return this.instance;
  }
  // 测试单体模式的实例
  var a = getInstance("aa");
  var b = getInstance("bb");

  // 随机生成 start 到 end 之间 num不重复的数字 num最大为start 到end之间的整数个数
  function random(start, end, num){
    var arr = [];
    for(var i=start;i<=end;i++){
      arr.push(i);
    };
    arr.sort(function(a, b){
      return 0.5 - Math.random();
    });
    return arr.slice(0,num);
  };

  function randomNumbers(start, end, num){
      var power = String(end).length;
      var arr = [];
      for(var i=0;i<num;i++){
          arr.push(parseInt(Math.random()*(end-start)) + start);
      };
      return arr;
  };
  var arr = randomNumbers(2,32,5);
  console.log(arr)
  </script>
</body>

</html>